import 'dart:math';
import 'dart:typed_data';
import 'dart:ui' as ui;
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter/cupertino.dart';
import '../const/AppConst.dart';
import '../storage/StorageManager.dart';
import 'PermissionUtil.dart';

class CommonUtil {

  static final RegExp _hasUpper = RegExp(r'[A-Z]');
  static final RegExp _hasLower = RegExp(r'[a-z]');
  static final RegExp _hasDigit = RegExp(r'[0-9]');
  static final RegExp _hasSpecial = RegExp(r'[!@#$%^&*(),.?":{}|<>]');

  static String? validatePassword(String? password) {
    if (password == null || password.isEmpty) {
      return '密码不能为空';
    }

    if (password.length < 8) {
      return '密码必须至少8个字符';
    }

    if (!_hasUpper.hasMatch(password)) {
      return '密码必须包含至少一个大写字母';
    }

    if (!_hasLower.hasMatch(password)) {
      return '密码必须包含至少一个小写字母';
    }

    if (!_hasDigit.hasMatch(password)) {
      return '密码必须包含至少一个数字';
    }

    if (!_hasSpecial.hasMatch(password)) {
      return '密码必须包含至少一个特殊符号';
    }

    return null; // 验证通过
  }


  static String? confirmValidatePassword(String? password,String? password2) {
    if (password == null || password.isEmpty) {
      return '密码不能为空';
    }

    if (password.length < 8) {
      return '密码必须至少8个字符';
    }

    if (!_hasUpper.hasMatch(password)) {
      return '密码必须包含至少一个大写字母';
    }

    if (!_hasLower.hasMatch(password)) {
      return '密码必须包含至少一个小写字母';
    }

    if (!_hasDigit.hasMatch(password)) {
      return '密码必须包含至少一个数字';
    }

    if (!_hasSpecial.hasMatch(password)) {
      return '密码必须包含至少一个特殊符号';
    }

    if (password2 != '' && password != password2) {
      return '两次密码不一致.';
    }

    return null; // 验证通过
  }


  static bool isEmail(String input) {
    if (input.isEmpty) return false;
    return RegExp("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*\$").hasMatch(input);
  }

  static bool isChinaPhoneLegal (String str) {
    return new RegExp('^((13[0-9])|(15[^4])|(166)|(17[0-8])|(18[0-9])|(19[8-9])|(147,145))\\d{8}\$').hasMatch(str);
  }


  static Uint8List intToByteArray(int value, int byteSize) {
    // 创建一个足够大的 Uint8List 来存储字节
    Uint8List byteArray = Uint8List(byteSize);

    // 将 int 分解为字节并存储到 Uint8List 中
    for (int i = 0; i < byteSize; i++) {
      // 通过位移和位与操作获取每个字节
      byteArray[byteSize - 1 - i] = (value >> (i * 8)) & 0xFF;
    }

    return byteArray;
  }

  static int bytesToInt(Uint8List bytes) {
    // 注意：这里假设字节顺序是小端序（least significant byte first），如果不是，请调整
    int result = 0;
    for (int i = 0; i < bytes.length; i++) {
      // 将每个字节左移适当的位数，并将其添加到结果中
      result = (result << 8) | bytes[i];
    }
    return result;
  }

  static String uint8ListToHex(Uint8List uint8List) {
    String hexString = '';
    for (int byte in uint8List) {
      // 将每个字节转换为两位的十六进制字符串
      String hex = byte.toRadixString(16).padLeft(2, '0');
      hexString = hexString + hex;
    }
    return hexString.toString();
  }




  static Uint8List hexStringToBytes(String hex) {
    // 确保十六进制字符串的长度是偶数，因为每两个十六进制字符表示一个字节
    if (hex.length % 2 != 0) {
      throw ArgumentError('Invalid hex string length.');
    }

    final result = Uint8List(hex.length ~/ 2);
    for (int i = 0; i < hex.length; i += 2) {
      final byte = int.parse(hex.substring(i, i + 2), radix:16);
      result[i ~/ 2] = byte;
    }
    return result;
  }


  static Uint8List listToInt8List(List<int> inputList) {
    // 检查输入列表中的每个元素是否在有效范围内（0-255）
    for (int value in inputList) {
      if (value < 0 || value > 255) {
        throw ArgumentError('List contains values outside the valid range for Uint8List (0-255).');
      }
    }

    // 创建一个 Uint8List 并使用 inputList 中的值初始化它
    Uint8List uint8List = Uint8List.fromList(inputList);

    return uint8List;
  }

  static Future<bool> checkBlueteethAndLocationDisable () async {
    if (await PermissionUtil.locationDisabled()) {
      return true;
    }
    if (await PermissionUtil.bluetoothDisabled()) {
      return true;
    }
    return false;
  }

  static Future<bool> checkNetWorkIsAvailable()  async {
    final List<ConnectivityResult> connectivityResult = await (Connectivity().checkConnectivity());

    if (connectivityResult.contains(ConnectivityResult.mobile)) {
      return true;
    } else if (connectivityResult.contains(ConnectivityResult.wifi)) {
      return true;
    } else {
      return false;
    }
  }


  static String getCurrentLoginToken() {
    return StorageManager.getStorage().hasData(AppConst.LOGIN_TOKEN) ?
    StorageManager.getStorage().read(AppConst.LOGIN_TOKEN)
    : '';
  }

  static bool hasEnteredAPPBefore() {
    return StorageManager.getStorage().hasData(AppConst.FIRST_LOGIN) ?
    StorageManager.getStorage().read(AppConst.FIRST_LOGIN)
        : false;
  }

  // 图片上传的域名
  static String getInterfaceUrl(){
    return 'http://sdk-test.newtranx.com/dev-apis';
  }
 // 获取图片前缀
static String getPicPre(){
    return 'http://sdk-test.newtranx.com/dev-apis/sys/common/static/';
}

  static Uint8List combineUint8Lists(Uint8List a, Uint8List b) {
    final combined = Uint8List(a.length + b.length);
    combined.setAll(0, a);
    combined.setAll(a.length, b);
    return combined;
  }

  static String getDateTimeByTakId(DateTime dateTime) {
    final day = dateTime.day;
    final month = dateTime.month;
    final year = dateTime.year;

    // 定义中文月份列表
    const months = ['一月', '二月', '三月', '四月', '五月', '六月',
      '七月', '八月', '九月', '十月', '十一月', '十二月'];

    return '${day.toString().padLeft(2,'0')} ${months[month - 1]} $year';
  }

  static DateTime parseChineseDate(String dateStr) {
    final parts = dateStr.split(' ');
    if (parts.length != 3) throw FormatException('无效日期格式');

    final day = parts[0].padLeft(2, '0');
    final chineseMonths = {
      '一月': '01', '二月': '02', '三月': '03',
      '四月': '04', '五月': '05', '六月': '06',
      '七月': '07', '八月': '08', '九月': '09',
      '十月': '10', '十一月': '11', '十二月': '12'
    };
    final month = chineseMonths[parts[1]] ?? '00';
    final year = parts[2];

    return DateTime.parse('$year-$month-$day');
  }


  static String formatCustomWeekday (DateTime dateTime) {
    final weekdays = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
    final day = dateTime.day;
    final month = dateTime.month;
    final year = dateTime.year;
    final hour = dateTime.hour;
    final minute = dateTime.minute;
    final second = dateTime.second;
    return '$year-${month.toString().padLeft(2, '0')}-${day.toString().padLeft(2, '0')} ${hour.toString().padLeft(2, '0')}:${minute.toString().padLeft(2, '0')}:${second.toString().padLeft(2, '0')}  ${weekdays[dateTime.weekday]}';
  }

  static String getMMSSFormate(int milliseconds) {
    // 1. 转换为总秒数（取整数部分）
    int totalSeconds = (milliseconds / 1000).floor();

    // 2. 计算分钟和剩余秒数
    int minutes = (totalSeconds ~/ 60);
    int seconds = totalSeconds % 60;

    // 3. 格式化为 MM:SS（两位补零）
    String formattedTime =
        '${minutes.toString().padLeft(2, '0')}'
        ':${seconds.toString().padLeft(2, '0')}';

    return formattedTime;
  }

  static String formatMillisecondsToHHMMSS(int sencond) {
    if (sencond < 0) return "00:00:00"; // 处理负数

    // 分解时间单位
    final duration = Duration(milliseconds: (sencond *1000));
    final hours = duration.inHours;
    final minutes = duration.inMinutes.remainder(60);
    final seconds = duration.inSeconds.remainder(60);

    // 格式化为两位数并拼接
    return '${_twoDigits(hours)}:${_twoDigits(minutes)}:${_twoDigits(seconds)}';
  }

  static String formatMillisecondsToHHMMSS_ForMillSeconds (int millSencond) {
    if (millSencond < 0) return "00:00:00"; // 处理负数

    // 分解时间单位
    final duration = Duration(milliseconds: millSencond);
    final hours = duration.inHours;
    final minutes = duration.inMinutes.remainder(60);
    final seconds = duration.inSeconds.remainder(60);

    // 格式化为两位数并拼接
    return '${_twoDigits(hours)}:${_twoDigits(minutes)}:${_twoDigits(seconds)}';
  }

  static String _twoDigits(int n) {
    return n.toString().padLeft(2, '0');
  }

  static String formatMillisecondsToHHMMSS2 (int sencond) {
    if (sencond < 0) return "00h00m00s"; // 处理负数

    // 分解时间单位
    final duration = Duration(milliseconds: (sencond *1000));
    final hours = duration.inHours;
    final minutes = duration.inMinutes.remainder(60);
    final seconds = duration.inSeconds.remainder(60);

    // 格式化为两位数并拼接
    return '${_twoDigits(hours)}h${_twoDigits(minutes)}m${_twoDigits(seconds)}s';
  }


  static double getScreenSize_ofWidth (BuildContext context) {
    // 获取物理尺寸（设备实际像素）
    final physicalSize = View.of(context).physicalSize;
    // 获取设备像素比（物理像素 / 逻辑像素）
    final pixelRatio = View.of(context).devicePixelRatio;

    // 计算逻辑尺寸（与 MediaQuery 结果一致）
    final screenWidth = physicalSize.width / pixelRatio;
    // final screenHeight = physicalSize.height / pixelRatio;

    print("屏幕宽度: ${physicalSize.width}");
    return physicalSize.width;
  }


  static double getScreenSize_ofHeight (BuildContext context) {
    // 获取物理尺寸（设备实际像素）
    final physicalSize = View.of(context).physicalSize;
    // 获取设备像素比（物理像素 / 逻辑像素）
    // final pixelRatio = View.of(context).devicePixelRatio;

    // 计算逻辑尺寸（与 MediaQuery 结果一致）
    //final screenWidth = physicalSize.width / pixelRatio;
    // final screenHeight = physicalSize.height / pixelRatio;

    print("屏幕高度: ${physicalSize.height}");
    return physicalSize.height;
  }


  static bool isNumeric(String str) {
    // 正则匹配：从开头到结尾均为数字，且至少一个字符
    return RegExp(r'^[0-9]+$').hasMatch(str);
  }
}
